Verification microservice for execution of a slice verification path by worker nodes

ABSTRACT

Described is a system for a verification microservice engine for generating and deploying a controller module and one or more worker nodes to detect corruption in a deduplicated object storage system accessible by one or more microservices while minimizing costly read operations on objects. A worker node(s) stores slice recipes into worker node memory that correspond to slice recipe names verified by a controller module. For each slice recipe, the worker node(s) detects whether slice recipe corruptions, similarity group corruptions and/or compression region corruptions exist.

TECHNICAL FIELD

This disclosure relates to deduplication systems, and more particularly, to relationship between data stored within deduplication systems.

BACKGROUND

In computing, a data storage system is a key component to store data for computation and transferring. Data files generally contain redundant data. For example, an email file may contain email threads that earlier emails are copied multiple times in the later replies. In an enterprise setting, many versions of the same information are stored for record keeping. Storing data files like these without modification wastes storage space and data deduplication is a way to reduce data redundancy in a storage system.

In a deduplication system, unique pieces of data, or byte patterns, in a file are identified as “chunks,” and they are stored during a process of analysis of the file. The analysis goes through the file, and other chunks are compared to the stored copy and whenever a match occurs, the redundant chunk is replaced with a small reference that points to the stored chunk. Because the same byte patterns may occur many times in a file, the amount of data that must be stored is greatly reduced.

Several factors affect deduplication efficiency. The amount of reduction of storage depends heavily on the distribution of the duplication within a file. The size of chunks also affects the reduction. A smaller chunk size saves more storage as it enables the system to identify more duplicates. However, a smaller chunk size increases the size of metadata, deduplication time, and fragmentation. Thus, the chunk size selection is a trade-off decision to a deduplication system. Another factor affecting the deduplication efficiency is how a file is divided up for deduplication. Ideally a file should be divided up in a way to maximize the possibility of finding duplicates. In a deduplication system, a file is divided up into data blocks, which are the units of deduplication.

BRIEF DESCRIPTION OF THE DRAWINGS

The accompanying drawings, which are incorporated into and constitute a part of this specification, illustrate embodiments of the disclosure and together with the description, serve to explain the principles of the disclosure.

FIG. 1A is a block diagram illustrating an example operating environment according to one or more embodiments of the disclosure.

FIG. 1B is a block diagram illustrating an example operating environment according to one or more embodiments of the disclosure.

FIG. 1C is a block diagram illustrating an example operating environment according to one or more embodiments of the disclosure.

FIG. 1D is a block diagram illustrating an example operating environment according to one or more embodiments of the disclosure.

FIG. 2 is a block diagram illustrating relationships between object recipes, slice recipes, similarity groups and compression regions according to one or more embodiments of the disclosure.

FIG. 3 is a block diagram illustrating naming conventions according to one or more embodiments of the disclosure.

FIG. 4 is a block diagram illustrating naming conventions according to one or more embodiments of the disclosure.

FIG. 5 is a block diagram illustrating a verification path condition according to one or more embodiments of the disclosure.

FIG. 6 is a block diagram illustrating phases of the verification path according to one or more embodiments of the disclosure.

FIG. 7A is a flow diagram illustrating an example method according to one or more embodiments of the disclosure.

FIG. 7B is a flow diagram illustrating an example method according to one or more embodiments of the disclosure.

FIG. 8 is a block diagram illustrating a phase according to one or more embodiments of the disclosure.

FIG. 9 is a block diagram illustrating a phase according to one or more embodiments of the disclosure.

FIG. 10 is a block diagram illustrating an example of a computing system that may be used in conjunction with one or more embodiments of the disclosure.

DETAILED DESCRIPTION

Various embodiments and aspects of the disclosures will be described with reference to details discussed below, and the accompanying drawings will illustrate the various embodiments. The following description and drawings are illustrative of the disclosure and are not to be construed as limiting the disclosure. Numerous specific details are described to provide a thorough understanding of various embodiments of the present disclosure. However, in certain instances, well-known or conventional details are not described in order to provide a concise discussion of embodiments of the present disclosure. Although these embodiments are described in sufficient detail to enable one skilled in the art to practice the disclosed embodiments, it is understood that these examples are not limiting, such that other embodiments may be used and changes may be made without departing from their spirit and scope. For example, the operations of methods shown and described herein are not necessarily performed in the order indicated and may be performed in parallel. It should also be understood that the methods may include more or fewer operations than are indicated. In some embodiments, operations described herein as separate operations may be combined. Conversely, what may be described herein as a single operation may be implemented in multiple operations.

Reference in the specification to “one embodiment” or “an embodiment” or “some embodiments,” means that a particular feature, structure, or characteristic described in conjunction with the embodiment can be included in at least one embodiment of the disclosure. The appearances of the phrase “embodiment” in various places in the specification do not necessarily all refer to the same embodiment.

In some embodiments, described is a system (and method and computer program product) for a verification microservice engine for generating and deploying a controller module and one or more worker nodes to detect object corruption in a deduplicated object storage system accessible by one or more microservices while minimizing costly read operations on objects. The verification microservice engine includes a worker node estimation module, a verification path module, and a controller deployment module and a worker node deployment module.

According to various embodiments, the verification microservice engine generates a controller module and one or more worker nodes to detect object relationship type corruptions in a plurality of objects stored in object storage of a deduplicated storage system. The verification microservice engine deploys the controller module and the one or more worker nodes for execution within a cloud computing environment that includes one or more microservices accessing the object storage via the deduplicated storage system. The verification microservice engine receives, from the controller module, one or more object relationship corruption instances detected by the controller module during a plurality of verification path phases for the controller module and one or more object relationship corruption instances detected by each worker node during a plurality of verification path phases.

A verify controller module and a plurality of worker nodes (i.e. virtual machines) are generated and deployed by the verification microservice engine to a cloud computing environment (such as, for example, a Kubernetes cloud computing environment). In various embodiments, the verification microservice engine instantiates the controller module and the one or more worker nodes to work in concert with each other to execute either a similarity group verification path or a slice recipe verification path in the cloud computing environment.

According to various embodiments, the controller module selects the similarity group verification path when a total memory size of all the slice recipe names in a data domain(s) is larger than the total memory size taken up by all the similarity groups in the same data domain(s). The controller module selects the slice recipe group verification path when a total memory size of all the slice recipe names in a data domain(s) is lower than the total memory size taken up by all the similarity groups in the same data domain(s).

For the slice recipe verification path, the controller module to performs controller phases and each worker node performs worker phases. The controller phases of the slice recipe verification path are: “list_sr_names,” “verify_sr,” “get_corrupted_objects” and “verify_controller_complete.” The worker node phases of the slice recipe verification path are “record_sr_names,” “verify_sg_to_sr,” “send_corrupted_objects” and “verify_worker_complete.”

According to various embodiments, the controller module builds local versions of slice recipe names based on metadata available object recipes. The controller module verifies the accuracy of the metadata based on whether the locally built slice recipes names match slice recipe names in object storage. For the slice recipe verification path, the controller module to initiates a list_sr_names phase to build at least one local slice recipe name string based on object recipe metadata. The object recipe metadata includes a respective object part identifier(s) and a respective slice number identifier(s). The controller module builds each local slice recipe string according to a slice recipe name format having a pre-defined object part identifier string placement and a pre-defined slice number identifier string placement. During the list_sr_name phase, the controller module verifies that the object recipe metadata used to generate a respective local slice recipe name is accurate based on the respective local slice recipe name matching any corresponding slice recipe name in the object storage. However, if respective local slice recipe name fails to match a corresponding slice recipe name in the object storage, then the failure to find a match represents an existence of a corruption of the object metadata used to generate that respective local slice recipe name. The controller module initiates a verify_sr phase, subsequent to the list_sr_name phase, to identify one or more similarity groups requiring verification during a verify_sg_to_sr worker node phase executed at the respective worker nodes.

According to various embodiments, for the slice recipe verification path, each worker node to initiates a record_sr_names phase to load a slice recipe(s) from object storage into its own worker node memory. Each slice recipe loaded into worker node memory corresponds to a particular slice recipe name sent from the controller module to a worker node that has been pre-assigned to a similarity group that is associated with the slice recipe identified by the slice recipe name. Each worker node initiates a verify_sg_to_sr phase based on receipt of a similarity group identifier(s) (such as a similarity group name or a similarity group) from the controller module. During the verify_sg_to_sr phase at each worker node, the worker node verifies whether there are any slice recipe corruptions, similarity group corruptions and/or compression region corruptions by processing slice recipes and one or more similarity groups that have been loaded into the worker node's memory. According to various embodiments, each worker node verifies existence of corruption by determining whether a fingerprint array in metadata of a slice recipe is consistent with a fingerprint array. The worker node also verifies existence of corruption by determining whether each fingerprint array in metadata of a similarity group is consistent with a corresponding compression region name in the metadata of the similarity group. Each worker node sends to the controller module during a send_corrupted_objects phase, any corruptions the worker node has detected.

In addition, the system provides many benefits in contrast with the limitations of conventional system. The system allows for verifying that all objects in object storage are valid and for confirming whether relationships between objects are still valid. Such relationships include: “object-to-slice recipe,” “slice recipe-to-similarity group” and “similarity group-to-compression region.”

In some embodiments, such a system may be provided within an operating environment. An example of such an operating environment is further described herein with reference to FIG. 1A. However, in general, embodiments of the disclosure may include and/or be implemented in an operating environment including a cloud services environment that may be, or include, a data protection operating environment that includes a backup and clustered storage environment. For example, at least some functionality may be provided by, or implemented in connection with, various platforms for data protection platform provided by Dell EMC™ Corporation, and associated systems, methods, and components, although use of this particular platform is provided only by way of illustration and is not required.

In some embodiments, the storage environment may take the form of a cloud storage environment. However, embodiments of the disclosure may also be implemented for an on-premises storage environment, and hybrid storage environments that include public and private elements, as well as any other type of storage environment. In addition, any of these cloud environments, or other operating environments, may take the form of an operating environment that is partly, or completely, virtualized. The storage environment may include one or more host devices that each host one or more applications used by a client of the storage environment. As such, a particular client may employ, or otherwise be associated with, one or more instances of each of one or more applications. In general, the applications employed by the clients are not limited to any particular functionality or type of functionality. Some example applications may include database applications (e.g. a SQL Server), filesystems, as well as other types of data stores. The applications on the clients may generate new and/or modified data that is desired to be protected.

Any of the devices, including the clients, servers and hosts, in the operating environment can take the form of software, physical machines, or virtual machines (VM), or any combination thereof, though no particular device implementation or configuration is required for any embodiment. Similarly, data protection system components such as databases, storage servers, storage volumes, storage disks, backup servers, restore servers, backup clients, and restore clients, for example, can likewise take the form of software, physical machines or virtual machines (VM), though no particular component implementation is required for any embodiment. Where VMs are employed, a hypervisor or other virtual machine monitor (VMM) can be employed to create and control the VMs.

As used herein, the term “data” is intended to be broad in scope. Accordingly, data may include data objects (or objects), data segments such as may be produced by data stream segmentation processes, data chunks, data blocks, atomic data, emails, files, contacts, directories, sub-directories, volumes, etc. In addition, the term “backup” (or “data backups,” “backed-up data,” etc.) is intended to be construed broadly and includes, but is not limited to, partial backups, incremental backups, full backups, clones, snapshots, any other type of copies of data, and any combination of the foregoing. Any of the foregoing may, or may not, be deduplicated. In addition, the storage of data can employ any suitable storage technique, infrastructure, hardware (e.g. Solid State Drive (SSD), Hard Disk Drive (HDD)), or on virtual storage systems provided by a cloud service provider, etc.

Exemplary Environments

More specifically, and with reference to FIG. 1A, shown is a block diagram illustrating an example of an operating environment 100 for distributing phases of deduplication processing within a clustered storage environment according to one or more embodiments of the disclosure. As shown, the environment 100 may include a client system 110, backup system 150, backup server 172, and a clustered storage system 180. It should be noted that the components of operating environment 100 may interact via a network 102, which may be any type of wired or wireless network including a local area network (LAN), a wide area network (WAN), or a direct communication link, or other suitable connection.

As shown, the operating environment 100 may include a client or client system (or computer, or device) 110 that may be associated with a client or customer of a data backup and protection service, and a backup system 150 that may be associated with a data backup and protection service provider. For example, the client system 110 may provide computing resources (e.g. webservers, databases, etc.) for users (e.g. website visitors) of the customer, data from which may be protected by the backup and data protection service provider. Accordingly, the client system 110 may act as a client from which backups are performed. In some embodiments, the client system 110 may comprise a virtual machine. In addition, the client system 110 may host one or more client applications 112, and may include data storage 114, as well as an interface for communicating with other systems and devices, such as the backup system 150. In general, the client applications 112 may create new and/or modified data that is desired to be protected. As such, the client system 110 is an example of a host device. The data storage 114 can be used to store client data, which may, along with the client system 110 (e.g. client applications 112) may be backed up using the backup system 150. As further described herein, components of the client system 110 (e.g. client applications, 112, data storage 114, etc.) may be a data source, or be associated with, one or more data sources such as a database, VM, storage device, etc. In addition, components of the client system 110 may be data sources that are associated with the client system 110, but reside on separate servers such as a data server, or a cloud-computing infrastructure. The client system 110 may include a backup client application, or plug-in application, or API that cooperates with backup system 150, to create backups of client data. The backed-up data can also be restored to the client system 110.

In one embodiment, backup component 150 may represent one or more components of a Data Domain Restorer (DDR)-based deduplication storage system, and backup server 172 may be implemented in conjunction with a Data Domain deduplication storage server provided by Dell EMC for use with DDR storage devices. For example, the backup server 172 may be a stand-alone entity, or can be an element of the clustered storage system 180. In some embodiments, the backup server 172 may be a Dell EMC Avamar server or a Dell EMC Networker server, although no particular server is required, and other backup and storage system configurations are contemplated.

The backup component 150, may include a backup application (or appliance) 152 that performs (or manages, coordinates, etc.) the creation and restoration of data that may be backed-up. For example, data to be backed-up from the client system 110 may be communicated from the client system 110 to the backup application 152 for initial processing, after which the processed data is uploaded from the backup application 152 for storage at the clustered storage system (e.g. as backup data 161). In some embodiments, the backup application 152 may cooperate with a backup client application of the client system 110 to back up client data to the clustered storage system 180. A backup application 152 may also cooperate with a backup client application to restore backup data from the clustered storage system 180 to the client system 110. In some embodiments, the backup application 152 may be a part of, or work in conjunction with, a storage appliance. For example, the storage appliance may include a Dell EMC CloudBoost appliance, although any suitable appliance is contemplated. In addition, the backup application 152 may provide a variety of useful functionalities such as source-side data deduplication, data compression, and WAN optimization boost performance and throughput while also possibly reducing the consumption and cost of network bandwidth and cloud storage capacity. One, some, or all, of these functions of the backup application 152 may be performed using deduplication logic via deduplication module 155. For example, the deduplication module 155 can provide data segmentation, as well as in-flight encryption as the data is sent by the storage application 152 to the clustered storage system 180. However, as further described herein, in some embodiments, data deduplication may be performed entirely within the clustered storage environment 180. It should be noted that the backup application (or storage appliance) 152 can be implemented in various forms, such as a virtual, physical, or native public cloud appliance to fit the requirements of a particular configuration, and the backup application 152 can be used with various types of data protection environments, including public and private object storage clouds.

The clustered storage system 180 (as further described herein) may store backup files 161 (or backup objects) within a one or more nodes (as further described herein). As shown, the clustered storage system 180 may also store metadata 162 for (or associated with) the backup files 161, and one or more instances of a filesystem 131 that catalogs backup files and other data residing in the clustered environment. In general, the storage of backup files 161 may be configured to store client system 110 data backups that can be restored in the event of a loss of data. The clustered storage system 180 may be an object storage system that includes object storage 180-1 (as further described herein).

As shown in FIG. 1B, a cloud-based system platform 190 (such as, for example, a Kubernetes cloud computing environment) may provide for the deployment of various types of microservices. The platform 190 may allow for the deployment of a plurality of verification services 192 for determining whether relationships between objects in object storage 180-1 are still valid. As shown in FIG. 1C, various types of verification microservices 192 may be a verification controller 192-1 (“controller module”) and a verification worker(s) 192-2 (“worker node(s)”).

As shown in FIG. 1D, the verification microservice engine 194 may be included within the backup component 150. The verification microservice engine 194 includes a worker estimation module 195 that estimates an optimal amount of worker nodes to be instantiated. A verification path module 197 includes a similarity group path module 197-1 to execute the similarity group verification path based on detection of a similarity group verification path condition. The verification path module 197 also includes a slice recipe path module 197-2 to execute the slice recipe verification path. The slice recipe verification path is executed based on detection of a slice recipe verification path condition. A controller deployment module 196-1 instantiates a controller module 192-1 to perform controller module functionalities. The controller deployment module 196-1 also deploys the controller module 192-1 to the platform 190. A worker deployment module 196-2 instantiates one or more worker nodes 192-2 to perform worker node functionalities. The worker deployment module 196-2 also deploys the one or more worker nodes 192-2 to the platform 190.

Object Recipes, Slice Recipes, Similarity Groups & Compression Regions

As shown in FIG. 2, a portion of object storage 180-1 may include a plurality of object recipes 202 (obj1, obj2, obj3), a plurality of slice recipes 204 (sl1 sl2, sl3), a plurality of similarity groups 206 (sg1, sg2, sg3, sg4) and a plurality of compressions regions 208 (cr1, cr2, cr3, cr4, cr5). In various embodiments, when a customer's object is written to a microservice via a client, the object is split or divided into one or more parts—or sets of segments. A fingerprint is computed for each segment from the object. In other words, an object part may have multiple segments and a fingerprint is computed for each segment of the object part. Thus, each fingerprint maps to a segment of an object part. Lists of fingerprints are organized into slice recipes. Specifically, a slice recipe may include an array of fingerprints and sizes of segments that correspond to each respective fingerprint in the array. A sketch may then be computed for each slice recipe according to one or more sketch algorithms.

Slice recipes may then be organized into similarity groups. Specifically, a similarity group may include one or more slice recipes that have the same computed sketch. Stated differently, slice recipes are similar to each other if they have the same sketch. An object recipe, then, forms a one-to-one mapping to customer objects and references the one or more slice recipes associated with the object, since the associated slice recipes are based on an array of fingerprints of the object's segment(s). The actual segments that are unique according to the deduplication service may be stored in in a compressed format in the compression regions.

Each object has a corresponding object recipe. The object recipe may be identified based on the name given to an object by the customer or user or by an object recipe naming convention that references the corresponding object and the object's data domain. In a specific embodiment, a name of the object recipe is generated by obtaining a name of an object (as provided by the user) and concatenating, augmenting, or tagging the object name with additional metadata or tags to form the name of the object recipe.

Data Structures, Metadata & Naming Conventions

As shown in FIG. 3, a diagram 300 illustrates an object recipe data structure 302 and a slice recipe data structure 304. The object recipe data structure 302 has metadata that indicates the number of parts of an object's data and an array stores metadata indicating how many slices of object data make up each individual object data part. Each slice may include one or more segments of object data, such as 8 KB of data. The slice recipe data structure 304 metadata further includes an internal reference variable indicating, for each object part indexed in the array, how many total slices correspond to that object part index.

Each object recipe has an object recipe name 302-1 that is a string in an object naming convention 302-2 (or object name format). The object naming convention 302-2 includes the object's data domain (“DD”), the data domain identifier (“ddid”), the object identifier (“OBJ”), customer data (“userbucketname,” “userobjname”) and an object version number (“objversion”). According to various embodiments, a data domain may represent a product line or be a pre-assigned unique prefix.

The slice recipe data structure 304 includes metadata that includes a reference to a similarity group and a fingerprint array. The reference to the similarity group indicates a “slice recipe-to-similarity group” relationship. As described above, fingerprints are computed for each data segment from an object. The fingerprint array, then, includes an array of the fingerprints for those fingerprints included in a slice and the fingerprint further includes the sizes of each segment represented by a fingerprint. The slice recipe also identifies the object data part to which the particular slice belongs.

Each slice recipe has a slice recipe name 304-1 that is a string in a slice recipe naming convention 304-2 (or slice recipe name format). The slice recipe naming convention 302-2 includes the slice recipe's data domain (“DD”), the data domain identifier (“ddid”), a slice recipe identifier (“SL”), customer data (“userobjname”), the version number (“objversion”) as was well indicating the object part (“P< . . . >”), an indication of which slice (from the slices for the object part) the slice recipe pertains (“S< . . . >”) and a similarity group identifier (“G< . . . >”) for the similarity group referenced in the slice recipe data structure 304.

As shown in FIG. 4, a diagram 400 illustrates a similarity group data structure 402 and a compression region data structure 404. The similarity group data structure 402 has metadata that includes a unique similarity group identifier. While a similarity group may reference multiple compression regions, each compression region itself is only referenced by a single similarity group. The similarity group data structure 402 metadata also includes an array of structures. Each structure includes a name of an underlying compression region name followed by a fingerprint array and corresponding segment sizes. Actual data segments (i.e. those data segments included in respective slices and represented by a specific fingerprint) that have been determined to be unique may be stored in a compressed format in a compression region, which is uniquely identified by its own compression region name—which is included in the similarity group data structure 402 metadata also includes an array of structures. Each compression region name in the metadata thereby indicates a “similarity group-to-compression region” relationship.

Each similarity group has a similarity group name 402-1 that is a string in a similarity group naming convention 402-2 (or similarity group name format). The similarity group naming convention 402-2 includes the similarity group's data domain (“DD”), which is a predetermined prefix string, the data domain identifier (“ddid”), a similarity group identifier (“SG”) which indicates the object being identified is a similarity group and that similarity group's actual identifier (“G”).

The compression region data structure 404 includes compressed unique data segments and the compressed data segment's correspond fingerprint and segment size. Each compression region has a compression region name 404-1 that is a string in a compression region naming convention 404-2 (or compression region name format). The compression region naming convention 404-2 includes the compression region's data domain (“DD”), the data domain identifier (“ddid”), a compression region identifier (“CR”), and user identifier (“Uid”). According to various embodiments, the “Uid” may be a hash value calculated over a fingerprint and segment size array which is used for a compression region name.

Slice Recipe Verification Path

As shown in FIG. 5, a diagram 500 illustrates that a controller module 192-1 determines whether to perform the slice recipe verification path based on detection of a particular condition. According to various embodiments, the slice recipe verification path will be executed if one of the two following cases occur: the total memory size in object storage 180-1 of all similarity groups in a data domain(s) is higher than a total memory size of all slice recipe names in the same data domain(s). In other embodiments, the slice group verification path may be forced (or triggered) via the values of one or more environment variables.

In various embodiments, during execution of the slice group verification path, the controller module 192-1 communicates with worker nodes and the worker nodes communicate with the controller via RPC calls. For each slice group verification path phase, the controller module 192-1 waits for all worker nodes to send a “finished” call before alerting the worker nodes to initiate a subsequent phase. Additionally, the controller module 192-1 and all worker nodes have a status check thread which runs according to a pre-defined interval. In the controller module 192-1, the status check thread attempts a simple RPC call to each worker node 192-2 to confirm its running state. In each worker node 192-2, the status check thread attempts a simple RPC call to the controller to confirm its running state as well. If any status check fails, the respective calling entity (controller module 192-1 or worker node 192-2) is responsible for stopping the slice group verification path and reporting the error.

As shown in FIG. 6, a diagram 600 illustrates a relationship between a controller workflow and a worker node workflow in the slice group verification path phase. The controller workflow includes various_phases, such as: “list_sr_names 601,” verify_sr 603,” “get_corrupted_objects 605,” and “verify_controller_complete 607.” The worker node workflow, for each worker node, includes various_phases, such as: “record_sr_names 621,” “verify_sg_to_sr 623,” “send_corrupted_objects 625” and “verify_worker_complete 627.”

The list_sr phase 601 precedes the record_sr_names phase 621. Once all worker nodes complete the record_sr_names phase 621, the controller module 192-1 will initiate the verify_sr phase 603, which includes calls to one or more worker nodes to initiate a verify_sg_to_sr phase 623. Once all worker nodes complete the verify_sg_to_sr phase 623, the controller module 192-1 will initiate the get_corrupted_objects phase 605—which includes calls to the one or more worker nodes to initiate the send_corrupted_objects phase 625. Once all worker nodes complete the send_corrupted_objects phase 625, the controller module 192-1 will verify completion (verify_controller_complete phase 607)—which includes calls to the one or more worker nodes to verify completion (verify_worker_complete phase 627). It is understood that each worker node 192-2 sends a phase completion message to the controller module 192-1 when the worker node 192-2 completes its execution of a worker node phase 621, 623, 625, 627.

Controller Module

In example method 700, as shown in FIG. 7A, at step 701, the controller module 192-1 selects a similarity group verification path based on a total memory size of similarity groups in the object storage being less than a total memory size of slice recipe names in the object storage and a slice verification path based on the total memory size being greater than a total memory size of slice recipe names in the object storage. At step 703, the controller module 192-1 identifies one or more similarity groups to be verified by a respective worker node pre-assigned to each identified similarity group. For example, the controller module 192-2 to initiates a verify_sr phase 603 to identify one or more similarity groups requiring verification by a verify_sg_to_sr phase 623 executed at respective worker nodes. In various embodiments, the controller module 192-1 iterates through the similarity groups in object storage 180-1. For example, the controller module 192-1 may cycle through similarity groups that belong to a same data domain or a plurality of data domains. The controller module 192-1 sends each similarity group to a respective pre-assigned worker node 192-1. For example, the controller module 192-1 may send a similarity group identifier or the similarity group to the pre-assigned worker node 192-1. In some embodiments, the verify_sr phase 603 may be subsequent to the list_sr_name phase 601 described at steps 705-709.

At step 705, the controller module 192-2 initiates a list_sr_names phase 601 to build a local slice recipe name string(s) based on object recipe metadata. The object recipe metadata includes a respective object part identifier(s) and a respective slice number identifier(s). The local slice recipe name string is built by the controller module 192-1 according to a slice recipe name format 304-2 having a pre-defined object part identifier string placement and a pre-defined slice number identifier string placement.

For example, the controller module 192-1 retrieves the object recipe from object storage 180-1. If there is an error retrieving the object recipe, the controller module 192-1 indicates that error from the failed retrieval of the object recipe as an existence of a corruption with respect to the object recipe. If no error occurs, the object recipe is decoded and one or more slice recipe names are recreated based on the metadata provided by the object recipe.

Since a slice recipe name format includes the object part number (“P< . . . >”), and a slice's number within the part (“S< . . . >”), the controller module 192-1 can cycle through the object recipe's metadata that indicates a total number of parts for the object and the array that lists how many slices correspond to data segments per object part. Stated differently, the controller module 192-1 accesses the object recipe metadata and recreates its own local version of a slice recipe name.

At step 707, the controller module 192-1 verifies the accuracy of object recipe metadata that is used to generate a respective local slice recipe name based on the respective local slice recipe name matching any corresponding slice recipe name in the object storage. Since the controller module 192-1 has recreated its own local version of one or more slice recipe names, the controller module 192-1 pulls slice recipe names from object storage 180-1 and compares the local list of slice recipe names and the actual slice recipe names that exist in object storage 180-1. If a slice recipe name pulled from object storage 180-1 does not have a corresponding matching local slice recipe name, the controller module 192-1 indicates an existence of a corruption with respect to the object metadata used for the local slice recipe name because at least a portion of the object recipe metadata used to generate the local slice recipe name is inaccurate.

At step 709, the controller module 192-2 sends each verified slice recipe name to a respective worker wonder 192-1. If the object recipe metadata is accurate and has not been modified, then using the object recipe metadata to generate local slice recipe names according the slice recipe naming convention 304-2 will result in an accurate local slice recipe name that has a matching corresponding slice recipe name stored in object storage 180-1. For each slice recipe name in object storage 180-1 that has a matching local slice recipe name built by the controller module 192-1, the controller module 192-1 sends the verified slice recipe name to a particular worker node 192-2. Each worker node 192-2 is pre-assigned to one or more similarity groups. The slice recipe name includes a similarity group identifier in accordance with the slice recipe name format 304-2. The controller module 192-1 accesses the similarity group identifier in the verified slice recipe name and sends the verified slice recipe name to a respective worker node 192-2 that has been pre-assigned to the similarity group that corresponds to the accessed similarity group identifier. It is understood that verified slice recipe names are sent to an appropriate worker node for execution of the worker node record_sr_names 621 phase.

Upon receipt from each worker node of a verify_sg_to_sr completion message, the controller module 192-1 initiates the get_corrupted_objects phase 605 to collect one or more corruptions identified by the controller module 192-1 and one or more corruptions identified by the plurality of worker nodes.

The get_corrupted_objects phase 605 consolidates corruptions identified by the controller module 192-1 and every worker node 192-2. The get_corrupted_objects phase 605 begins by the controller module 192-1 sending an RPC request to each worker node 192-2 requesting initiation of the send_corrupted_objects worker node phase 625. The controller module 192-1 receives, from each worker node 192-2, one or more corruptions identified during a worker node 192-2 phase 621, 623. The controller module 192-1 includes each worker node corruption into a corrupted object map that also includes those corruptions the controller module 192-1 identified.

The controller module 192-1 then prompts each worker node 192-2 to begin the verify_worker_complete phase 627 while the controller module 192-1 executes the verify_controller_complete phase 607. The verify_controller_complete phase 607 is responsible for printing out results and wrapping up verification. The verify_controller_complete phase 607 begins by closing the worker status channel previous used to ensure all workers were in a running state. Next, the controller module 192-1 prints out relevant stats about verification along with any corrupt objects in the corrupted object map. The controller module 192-1 then closes a phase channel as there are no more phases left to complete. The controller module 192-1 also writes a starting timestamp of the current slice recipe verification path run to configuration storage so that it can be referenced the next time another slice receipt verification path is executed.

Worker Node(s)

In example method 711, as shown in FIG. 7B, each worker node 192-2 initiates a record_sr_names phase 621 to store a slice recipe(s) into worker node memory (or “worker memory”) from object storage 180-1, where each slice recipe corresponds to a verified slice recipe name received from the controller module 192-1 (step 713). In various embodiments, the controller module 192-1 sends one or more verified slice recipe names to each worker node 192-2. Slice recipes correspond to a similarity group and each similarity group has been pre-assigned to a specific worker node 192-2. The controller module 192-1 thereby sends a slice recipe name to a specific worker node 192-2 that has been pre-assigned to a similarity group that corresponds with the named slice recipe.

The worker node 192-2 sorts all slice recipes, that correspond to slice recipe names received from the controller module 192-1, into slice recipe lists (or slice recipe mappings). Each slice recipe list is associated with a specific similarity group identifier and/or data domain identifier. For example, multiple slice recipes that reference the same similarity group will thereby be placed in the same slice recipe lists (or slice recipe mappings).

At step 715, each worker node 192-2 initiates a verify_sg_to_sr phase 623 based on receipt of one or more similarity groups (or similarity group identifiers) from the controller module 192-1. In the verify_sg_to_sr phase 623, each worker node 192-2 processes slice recipe lists (or slice recipe mappings) generated during the preceding record_sr_names phase 621. Once the worker node 192-2 has identified similarity groups and slice recipes that require verification, the worker node 192-2 seeks to identify various object corruptions.

At step 717, during the verify_sg_to_sr phase 623, the worker node 192-2 detects whether slice recipe corruptions, similarity group corruptions and/or compression region corruptions exist. The worker node 192-2 stores the similarity group from object storage into worker node memory. The worker memory already includes the slice recipes from the preceding record_sr_names phase 621. If there is an error retrieving the similarity group from object storage 180-1, the worker node 192-2 will record the error as an existence of a corruption with respect to the failure to retrieve the similarity group.

According to various embodiments, it is understood that a similarity group may have multiple, different fingerprint and corresponding segment size arrays (“fingerprint arrays”) stored as metadata such that a fingerprint array of a respective slice recipe may be compared to each different fingerprint array in the similarity group's metadata to determine whether there has been a corruption detected on the basis of the slice recipe fingerprint array failing to match up with any of the similarity group's metadata fingerprint arrays. If the slice recipe fingerprint array matches up with one of the multiple fingerprint arrays stored in the similarity group's metadata, such a match indicates no corruption has occurred. Stated differently, if a particular fingerprint from a slice recipe array is not located in any of the multiple fingerprint arrays stored in the similarity group's metadata, then a corruption has been identified as to the relationship between the corresponding slice recipe and similarity group. Such a corruption may be that a slice recipe has become corrupted such that a fingerprint in the slice recipe has been modified.

The worker node 192-2 also verifies existence of a similarity group corruption based on a comparison between the first fingerprint array and a compression region name that are both in the metadata of the corresponding similarity group. As already discussed, each similarity group has an array of structures. Each structure includes a compression region name associated with an array of fingerprints and segment sizes (“first fingerprint array”). Compression region names themselves are based on a hash (“Uid”) of a corresponding fingerprint array. The worker node 192-2 calculates a temporary hash score for each fingerprint array and compares the temporary hash score to the fingerprint array's corresponding compression region name in the similarity group's metadata. If the temporary hash score does not match the compression region name from the similarity group's metadata, the worker node 192-2 will record an existence of a corruption with respect to the similarity group. Such an existence of a corruption indicates that some portion(s) of the fingerprint array in the similarity group used to calculate the temporary hash score is inaccurate because if the fingerprint was accurate than its corresponding temporary hash score would result in a compression region name that can be found in the similarity group's metadata. Alternatively, the corruption indicates that the compression region name in the similarity group's metadata has become corrupted.

The worker node also verifies existence of a compression region corruption during the verify_sg_to_sr phase 623. Determining an existence of a compression region corruption based on a comparison between the compression region name and object storage (step 709). For example, worker node 192-2 attempts to locate a compression region that is actually in object storage 180-1 based on the compression region name in the similarity group's metadata—as opposed to executing a costly read operation of a compression region in object storage 180-1. If no compression region is found, the worker node 192-2 will record an existence of a corruption with respect to the compression region. Such an existence of a corruption indicates the compression region cannot be located in object storage after a call for the compression region using a compression region name from the similarity group that has already be validated as accurate by a matching temporary hash score. Upon completion of the verify_sg_to_sr phase 623, each worker node 192-2 may release slice recipes and similarity groups from worker node memory.

At step 719, each worker node 192-2 sends one or more instances of slice recipe, similarity group and compression region corruptions to the controller module 192-1. In various embodiments, each worker node 192-2 tracks instances of corruption detected during its worker node phases 621, 623, 625, 627. In the send_corrupted_objects phase 625, each worker node 192-2 simply makes an RPC call to the controller module 192-1 with a list of corrupt objects that the worker node 192-2 detected In addition, during the subsequent verify_worker_complete phase 627, each worker node 192-2 closes any of its active channels and prints out phase data to one or more logs and shuts down.

As noted, the operations (or steps) shown in the above in the methods 701, 711 are not necessarily performed in the order indicated and may be performed in parallel, as a single operation, or as multiple operations.

Slice Recipe Verification Path: Worker Node “Verify SR to SG” Phase

As shown in the diagram 800 of FIG. 8, the worker node 192-2 executes the verify_sg_to_sr phase 623 with respect to a slice recipe(s) 810 loaded into worker node memory 804 during the record_sr_names phase 621. It is understood that the slice recipe 810 belongs to a slice recipe list (or slice recipe mapping) that corresponds with a particular similarity group. The worker node 192-2 accesses object storage 180-1 and locates a similarity group 806 that corresponds to a similarity group identifier 802 (such as a similarity group name) sent by the controller module 192-1 during its verify_sr_path phase 603. The worker node 192-2 loads the similarity group 806 into worker node memory 804. The worker node 192-2 confirms the slice recipe 810 belongs to a slice recipe list associated with the loaded similarity group 806. The worker node 192-1 accesses the entries of the fingerprint array 808 in the similarity group's 806 metadata and the entries in the fingerprint array 812 in the slice recipe's 810 metadata. The worker node 192-2 compares the entries in the fingerprint arrays 808, 812. If there are entries that do not match, the worker node 192-2 will record an existence of a corruption with respect to the slice recipe 812. Such a corruption may be that a slice recipe has become corrupted such that a fingerprint in the slice recipe has been modified.

As shown in the diagram 900 of FIG. 9, metadata of the similarity group 806 in worker node memory 804 has a compression region name 810 associated with a fingerprint array 808 in its metadata. However, it is understood that the similarity group 806 may have metadata that includes multiple compression region names where each compression region name may be associated with a respective fingerprint array having one or more fingerprints and corresponding segment sizes. The worker node 192-2 calculates a temporary hash value based on the fingerprint array 808. The worker node compares the temporary hash value to the compression region name 810 associated with the fingerprint array 808. If the temporary hash value does not match the compression region name 810, the worker node 192-2 will record an existence of a corruption with respect to the similarity group 806.

The worker node 192-2 may also attempt to locate a compression region that is actually in object storage 180-1 based on the compression region name 810 in the similarity group's metadata. If no compression region is found, the worker node 192-2 will record an existence of a corruption with respect to the compression region without the cost of reading one or more compression regions directly from object storage 180-1. By leveraging verification of the referential integrity as between a respective similarity group's compression region name metadata and the compression region itself, the verification path minimizes the compression regions that must be read for verification.

Exemplary Computing System

FIG. 10 shows a block diagram of an example of a computing system that may be used in conjunction with one or more embodiments of the disclosure. For example, computing system 1000 (or system, or server, or computing device, or device) may represent any of the devices or systems described herein that perform any of the processes, operations, or methods of the disclosure. Note that while the computing system 1000 illustrates various components, it is not intended to represent any particular architecture or manner of interconnecting the components as such details are not germane to the present disclosure. It will also be appreciated that other types of systems that have fewer or more components than shown may also be used with the present disclosure.

As shown, the computing system 1000 may include a bus 1005 which may be coupled to a processor 1010, ROM (Read Only Memory) 1020, RAM (or volatile memory) 1025, and storage (or non-volatile memory) 1030. The processor(s) 1010 may retrieve stored instructions from one or more of the memories 1020, 1025, and 1030 and execute the instructions to perform processes, operations, or methods described herein. These memories represent examples of a non-transitory computer-readable medium (or machine-readable medium, a computer program product, etc.) containing instructions (or program code) which when executed by a processor (or system, device, etc.), cause the processor to perform operations, processes, or methods described herein.

As referred to herein, for example, with reference to the claims, a processor may include one or more processors. Moreover, the one or more processors 1010 may perform operations in an on-demand or “cloud computing” environment or as a service (e.g. within a “software as a service” (SaaS) implementation). Accordingly, the performance of operations may be distributed among the one or more processors 1010, whether residing only within a single machine or deployed across a number of machines. For example, the one or more processors 1010 may be located in a single geographic location (e.g. within a home environment, an office environment, or a server farm), or may be distributed across a number of geographic locations. The RAM 1025 may be implemented as, for example, dynamic RAM (DRAM), or other types of memory that require power continually in order to refresh or maintain the data in the memory. Storage 1030 may include, for example, magnetic, semiconductor, tape, optical, removable, non-removable, and other types of storage that maintain data even after power is removed from the system. It should be appreciated that storage 1030 may be remote from the system (e.g. accessible via a network).

A display controller 1050 may be coupled to the bus 1005 in order to receive display data to be displayed on a display device 1055, which can display any one of the user interface features or embodiments described herein and may be a local or a remote display device. The computing system 1000 may also include one or more input/output (I/O) components 1065 including mice, keyboards, touch screen, network interfaces, printers, speakers, and other devices. Typically, the input/output components 1065 are coupled to the system through an input/output controller 1060.

Program code 1070 may represent any of the instructions, applications, software, libraries, toolkits, modules, components, engines, units, functions, logic, etc. as described herein. Program code 1070 may reside, completely or at least partially, within the memories described herein (e.g. non-transitory computer-readable media), or within a processor during execution thereof by the computing system. Program code 1070 may include both machine code, such as produced by a compiler, and files containing higher-level or intermediate code that may be executed by a computing system or other data processing apparatus (or machine) using an interpreter. In addition, program code 1070 can be implemented as software, firmware, or functional circuitry within the computing system, or as combinations thereof. Program code 1070 may also be downloaded, in whole or in part, through the use of a software development kit or toolkit that enables the creation and implementation of the described embodiments.

Moreover, any of the disclosed embodiments may be embodied in various types of hardware, software, firmware, and combinations thereof. For example, some techniques disclosed herein may be implemented, at least in part, by non-transitory computer-readable media that include program instructions, state information, etc., for performing various methods and operations described herein.

It should be noted that references to ordinal numbers such as “first,” “second,” “third,” etc., may indicate an adjective for an element (e.g. any noun in the application). The use of ordinal numbers does not necessarily imply or create any particular ordering of the elements nor limit any element to being only a single element unless expressly disclosed, such as by the use of the terms “before,” “after,” “single,” and other such terminology. Rather, the use of ordinal numbers is to distinguish between the elements. By way of an example, a first element is distinct from a second element, and the first element may encompass more than one element and succeed (or precede) the second element in an ordering of elements. In addition, the use of the term “or” indicates an inclusive or (e.g. and/or) unless otherwise specified. For example, the phrase “at least one of x, y, or z” means any one of x, y, and z, as well as any combination thereof. In addition, the term “based on” is used to describe one or more factors that affect a determination. These terms do not foreclose additional factors that may affect a determination. For example, the phrase “determining A based on B” includes B being a factor that affects the determination of A, and does not foreclose the determination of A from also being based on C. However, in other instances, A may be determined based solely on B, such as by the use of the terms “only,” “solely,” and other such terminology. In addition, the term “approximately” or “substantially” may be used herein and may be interpreted as “as nearly as practicable,” “within technical limitations,” and the like.

Other embodiments of the disclosure will be apparent to those skilled in the art from consideration of the specification and practice of the invention disclosed herein. It is intended that the specification and examples be considered as examples only, with a true scope and spirit of the embodiments being indicated by the claims. 

What is claimed is:
 1. A computer-implemented method, comprising: storing, by a worker node, at least one slice recipe into worker node memory from object storage, the at least one loaded slice recipe corresponding to a slice recipe name received from a controller module; receiving, by the worker node, one or more similarity group identifiers from the controller module; detecting, by the worker node: (i) whether a slice recipe corruption exists for each slice recipe in worker node memory based on a comparison between metadata of the respective slice recipe and metadata of a corresponding similarity group identified by the controller module, (ii) whether a similarity group corruption exists based on a comparison between a first fingerprint array and a compression region name in the metadata of the corresponding similarity group, and (iii) whether a compression region corruption exists based on a comparison between the compression region name and object storage; and sending, by the worker node, one or more instances of slice recipe, similarity group and compression region corruptions to the controller module.
 2. The computer-implemented method of claim 1, further comprising: receiving, by the worker node, one or more slice recipe names identified by the controller module as needing to be verified, the one or more identified slice recipe names corresponding to respective similarity groups pre-assigned to the worker node; loading into worker node memory, by the worker node, a slice recipe from object storage that corresponds to the slice recipe name; accessing, by the worker node, a similarity group identifier in the loaded slice recipe; and storing, by the worker node, the loaded slice recipe in a slice recipe list associated with the similarity group identifier.
 3. The computer-implemented method of claim 2, further comprising: sorting, by the worker node, the slice recipe, that were loaded into worker memory, into slice recipe lists associated with a respective similarity group identifiers; and sending, by the worker node, a completion message to the controller module notifying the controller module that sorting slice recipes is complete.
 4. The computer-implemented method of claim 1, further comprising: identifying, by the worker node, a corruption of a respective slice recipe based on detecting a fingerprint within a fingerprint array in metadata of the respective slice recipe does not match any fingerprints stored amongst a plurality of fingerprint arrays in metadata of a similarity group associated with the respective slice recipe, each fingerprint array including a fingerprint indexed to a plurality of corresponding segment sizes, the slice recipe corruption indicating that the fingerprint in the respective slice recipe that fails to match has been improperly modified.
 5. The computer-implemented method of claim 1, further comprising: determining, by the worker node, a temporary hash score based on a particular fingerprint array from a plurality of fingerprint arrays stored in metadata of a respective similarity group, wherein each fingerprint array comprises a fingerprint indexed to a plurality of corresponding segment sizes; accessing, by the worker node, a compression region name in the metadata of the respective similarity group, the accessed compression region name associated with the particular fingerprint array; and identifying, by the worker node, a corruption of the respective similarity group based on the temporary hash score failing to match the accessed compression region name, the similarity group corruption indicating one or more portions of the particular fingerprint array in the metadata of the respective similarity group have been improperly modified.
 6. The computer-implemented method of claim 5, further comprising: calling, by the worker node, object storage according to the accessed compression region name in response to determining that the temporary hash score matches the accessed compression region name; and identifying, by the worker node, the compression region corruption on a failure to retrieve a compression region in object storage identified by the accessed compression region name.
 7. The computer-implemented method of claim 1, further comprising: sending to the controller module, by the worker node, a message indicating completion of all attempts for identifying existence of respective slice recipe and similarity group corruption verifications.
 8. A system comprising: one or more processors; and a non-transitory computer readable medium storing a plurality of instructions, which when executed, cause the one or more processors to: store, by a worker node, at least one slice recipe into worker node memory from object storage, the at least one loaded slice recipe corresponding to a slice recipe name received from a controller module; receive, by the worker node, one or more similarity group identifiers from the controller module; detect, by the worker node: (i) whether a slice recipe corruption exists for each slice recipe in worker node memory based on a comparison between metadata of the respective slice recipe and metadata of a corresponding similarity group identified by the controller module, (ii) whether a similarity group corruption exists based on a comparison between a first fingerprint array and a compression region name in the metadata of the corresponding similarity group, and (iii) whether a compression region corruption exists based on a comparison between the compression region name and object storage; and send, by the worker node, one or more instances of slice recipe, similarity group and compression region corruptions to the controller module.
 9. The system of claim 8, wherein the plurality of instructions, when executed, further cause the one or more processors to: receive, by the worker node, one or more slice recipe names identified by the controller module as needing to be verified, the one or more identified slice recipe names corresponding to respective similarity groups pre-assigned to the worker node; load into worker node memory, by the worker node, a slice recipe from object storage that corresponds to the slice recipe name; access, by the worker node, a similarity group identifier in the loaded slice recipe; and store, by the worker node, the loaded slice recipe in a slice recipe list associated with the similarity group identifier.
 10. The system of claim 9, wherein the plurality of instructions, when executed, further cause the one or more processors to: sort, by the worker node, the loaded slice recipe loaded into worker node memory into slice recipe lists associated with a respective similarity group identifiers; and send, by the worker node, a completion message to the controller module notifying the controller module that sorting slice recipes is complete.
 11. The system of claim 8, wherein the plurality of instructions, when executed, further cause the one or more processors to: identify, by the worker node, a corruption of a respective slice recipe based on detecting a fingerprint within a fingerprint array in metadata of the respective slice recipe does not match any fingerprints stored amongst a plurality of fingerprint arrays in metadata of a similarity group associated with the respective slice recipe, the fingerprint array including a fingerprint indexed to a plurality of corresponding segment sizes, the slice recipe corruption indicating that the fingerprint in the respective slice recipe that fails to match has been improperly modified.
 12. The system of claim 8, wherein the plurality of instructions, when executed, further cause the one or more processors to: determine, by the worker node, a temporary hash score based on a particular fingerprint array from a plurality of fingerprint arrays stored in metadata of a respective similarity group, wherein each fingerprint array comprises a fingerprint indexed to a plurality of corresponding segment sizes; access, by the worker node, a compression region name in the metadata of the respective similarity group, the accessed compression region name associated with the particular fingerprint array; identify, by the worker node, a corruption of the respective similarity group based on the temporary hash score failing to match the accessed compression region name, the similarity group corruption indicating one or more portions of the particular fingerprint array in the metadata of the respective similarity group have been improperly modified.
 13. The system of claim 12, wherein the plurality of instructions, when executed, further cause the one or more processors to: call, by the worker node, object storage according to the accessed compression region name in response to determining that the temporary hash score matches the accessed compression region name; and identify, by the worker node, the compression region corruption on a failure to retrieve a compression region in object storage identified by the accessed compression region name.
 14. The system of claim 8, wherein the plurality of instructions, when executed, further cause the one or more processors to: send, by the worker node, to the controller module, by the worker node, a message indicating completion of all attempts for identifying existence of respective slice recipe and similarity group corruption verifications.
 15. A computer program product comprising a non-transitory computer-readable medium having a computer-readable program code embodied therein to be executed by one or more processors, the program code including instructions to: store, by a worker node, at least one slice recipe into worker node memory from object storage, the at least one loaded slice recipe corresponding to a slice recipe name received from a controller module; receive, by the worker node, one or more similarity group identifiers from the controller module; detect, by the worker node: (i) whether a slice recipe corruption exists for each slice recipe in worker node memory based on a comparison between metadata of the respective slice recipe and metadata of a corresponding similarity group identified by the controller module, (ii) whether a similarity group corruption exists based on a comparison between a first fingerprint array and a compression region name in the metadata of the corresponding similarity group, and (iii) whether a compression region corruption exists based on a comparison between the compression region name and object storage; and send, by the worker node, one or more instances of slice recipe, similarity group and compression region corruptions to the controller module.
 16. The computer program product of claim 15, the program code including further instructions to: receive, by the worker node, one or more slice recipe names identified by the controller module as needing to be verified, the one or more identified slice recipe names corresponding to respective similarity groups pre-assigned to the worker node; load into worker node memory, by the worker node, slice recipe from object storage that corresponds to the slice recipe name; access, by the worker node, a similarity group identifier in the loaded slice recipe; and store, by the worker node, the loaded slice recipe in a slice recipe list associated with the similarity group identifier.
 17. The computer program product of claim 16, the program code including further instructions to: sort, by the worker node, the slice recipe, that were loaded into worker memory, into slice recipe lists associated with a respective similarity group identifiers; and send, by the worker node, a completion message to the controller module notifying the controller module that sorting slice recipes is complete.
 18. The computer program product of claim 15, the program code including further instructions to: identify, by the worker node, a corruption of a respective slice recipe based on detecting a fingerprint within a fingerprint array in metadata of the respective slice recipe does not match any fingerprints stored amongst a plurality of fingerprint arrays in metadata of a similarity group associated with the respective slice recipe, the fingerprint array including a fingerprint indexed to a plurality of corresponding segment sizes, the slice recipe corruption indicating that the fingerprint in the respective slice recipe that fails to match has been improperly modified.
 19. The computer program product of claim 15, the program code including further instructions to: determine, by the worker node, a temporary hash score based on a particular fingerprint array from a plurality of fingerprint arrays stored in metadata of a respective similarity group, wherein each fingerprint array comprises a fingerprint indexed to a plurality of corresponding segment sizes; access, by the worker node, a compression region name in the metadata of the respective similarity group, the accessed compression region name associated with the particular fingerprint array; identify, by the worker node, a corruption of the respective similarity group based on the temporary hash score failing to match the accessed compression region name, the similarity group corruption indicating one or more portions of the particular fingerprint array in the metadata of the respective similarity group have been improperly modified.
 20. The computer program product of claim 19, the program code including further instructions to: call, by the worker node, object storage according to the accessed compression region name in response to determining that the temporary hash score matches the accessed compression region name; and identify, by the worker node, the compression region corruption on a failure to retrieve a compression region in object storage identified by the accessed compression region name. 